using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using Server;
using Server.Network;

namespace Server.Accounting
{
	public class AccountAttackLimiter
	{
		public static bool Enabled = true;

		public static void Initialize()
		{
			if ( !Enabled )
				return;

			PacketHandlers.RegisterThrottler( 0x80, new ThrottlePacketCallback( Throttle_Callback ) );
			PacketHandlers.RegisterThrottler( 0x91, new ThrottlePacketCallback( Throttle_Callback ) );
			PacketHandlers.RegisterThrottler( 0xCF, new ThrottlePacketCallback( Throttle_Callback ) );
		}

		public static bool Throttle_Callback( NetState ns )
		{
			InvalidAccountAccessLog accessLog = FindAccessLog( ns );

			if ( accessLog == null )
				return true;

			return ( DateTime.Now >= (accessLog.LastAccessTime + ComputeThrottle( accessLog.Counts )) );
		}

		private static List<InvalidAccountAccessLog> m_List = new List<InvalidAccountAccessLog>();

		public static InvalidAccountAccessLog FindAccessLog( NetState ns )
		{
			if ( ns == null )
				return null;

			IPAddress ipAddress = ns.Address;

			for ( int i = 0; i < m_List.Count; ++i )
			{
				InvalidAccountAccessLog accessLog = m_List[i];

				if ( accessLog.HasExpired )
					m_List.RemoveAt( i-- );
				else if ( accessLog.Address.Equals( ipAddress ) )
					return accessLog;
			}

			return null;
		}

		public static void RegisterInvalidAccess( NetState ns )
		{
			if ( ns == null || !Enabled )
				return;

			InvalidAccountAccessLog accessLog = FindAccessLog( ns );

			if ( accessLog == null )
				m_List.Add( accessLog = new InvalidAccountAccessLog( ns.Address ) );

			accessLog.Counts += 1;
			accessLog.RefreshAccessTime();

			if ( accessLog.Counts >= 3 ) {
				try {
					using ( StreamWriter op = new StreamWriter( "throttle.log", true ) ) {
						op.WriteLine(
							"{0}\t{1}\t{2}",
							DateTime.Now,
							ns,
							accessLog.Counts
						);
					}
				}
				catch {
				}
			}
		}

		public static TimeSpan ComputeThrottle( int counts )
		{
			if ( counts >= 15 )
				return TimeSpan.FromMinutes( 5.0 );

			if ( counts >= 10 )
				return TimeSpan.FromMinutes( 1.0 );

			if ( counts >= 5 )
				return TimeSpan.FromSeconds( 20.0 );

			if ( counts >= 3 )
				return TimeSpan.FromSeconds( 10.0 );

			if ( counts >= 1 )
				return TimeSpan.FromSeconds( 2.0 );

			return TimeSpan.Zero;
		}
	}

	public class InvalidAccountAccessLog
	{
		private IPAddress m_Address;
		private DateTime m_LastAccessTime;
		private int m_Counts;

		public IPAddress Address
		{
			get{ return m_Address; }
			set{ m_Address = value; }
		}

		public DateTime LastAccessTime
		{
			get{ return m_LastAccessTime; }
			set{ m_LastAccessTime = value; }
		}

		public bool HasExpired
		{
			get{ return ( DateTime.Now >= ( m_LastAccessTime + TimeSpan.FromHours( 1.0 ) ) ); }
		}

		public int Counts
		{
			get{ return m_Counts; }
			set{ m_Counts = value; }
		}

		public void RefreshAccessTime()
		{
			m_LastAccessTime = DateTime.Now;
		}

		public InvalidAccountAccessLog( IPAddress address )
		{
			m_Address = address;
			RefreshAccessTime();
		}
	}
}